home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / AIncludes / OCE.a < prev    next >
Encoding:
Text File  |  1996-05-01  |  55.6 KB  |  1,877 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        OCE.a
  3. ;
  4. ;    Contains:    Apple Open Collaboration Environment (AOCE) Interfaces.
  5. ;
  6. ;    Version:    Technology:    AOCE Toolbox 1.02
  7. ;                Release:    Universal Interfaces 3.0d3 on Copland DR1
  8. ;
  9. ;    Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10. ;
  11. ;    Bugs?:        If you find a problem with this file, send the file and version
  12. ;                information (from above) and the problem description to:
  13. ;
  14. ;                    Internet:    apple.bugs@applelink.apple.com
  15. ;                    AppleLink:    APPLE.BUGS
  16. ;
  17. ;
  18.     IF &TYPE('__OCE__') = 'UNDEFINED' THEN
  19. __OCE__ SET 1
  20.  
  21.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  22.     include 'Types.a'
  23.     ENDIF
  24.     IF &TYPE('__ALIASES__') = 'UNDEFINED' THEN
  25.     include 'Aliases.a'
  26.     ENDIF
  27.     IF &TYPE('__APPLEEVENTS__') = 'UNDEFINED' THEN
  28.     include 'AppleEvents.a'
  29.     ENDIF
  30.     IF FOR_SYSTEM7_ONLY THEN
  31. ;  All utility routines defined here are callable at interrupt level. 
  32. ; typedef unsigned short                 OCERecordTypeIndex
  33.  
  34. ; typedef unsigned short                 OCEAttributeTypeIndex
  35.  
  36. ;
  37. ; For anyone who absolutely needs a define of the body of the standard record or
  38. ;attribute type, use these below.  CAUTION!  All the types below are assumed to be
  39. ;in character set 'smRoman'.  If you try to compare these to some RString or
  40. ;AttributeType variable, you must take the character set code into account.  Future
  41. ;standard types may be defined using character sets other than 'smRoman'. 
  42. ;
  43. ;
  44. ; All these standard definitions begin with the Apple symbol (not shown here).
  45. ;
  46. ;NOTE:  To access these, you must call OCEGetIndRecordType or OCEGetIndAttributeType
  47. ;with the proper index.  These routines return pointers to the standard type.
  48. ;This was done so that code fragments (INITs, CDEVs, CSAMs, etc). which cannot
  49. ;use global data can also use these. 
  50. ;
  51. ;  Indices for the standard definitions for certain record types (OCERecordTypeIndex): 
  52.  
  53. kUserRecTypeNum                    EQU        1                    ; "User" 
  54. kGroupRecTypeNum                EQU        2                    ; "Group" 
  55. kMnMRecTypeNum                    EQU        3                    ; "AppleMail™ M&M" 
  56. kMnMForwarderRecTypeNum            EQU        4                    ; "AppleMail™ Fwdr" 
  57. kNetworkSpecRecTypeNum            EQU        5                    ; "NetworkSpec" 
  58. kADAPServerRecTypeNum            EQU        6                    ; "ADAP Server" 
  59. kADAPDNodeRecTypeNum            EQU        7                    ; "ADAP DNode" 
  60. kADAPDNodeRepRecTypeNum            EQU        8                    ; "ADAP DNode Rep" 
  61. kServerSetupRecTypeNum            EQU        9                    ; "Server Setup" 
  62. kDirectoryRecTypeNum            EQU        10                    ; "Directory" 
  63. kDNodeRecTypeNum                EQU        11                    ; "DNode" 
  64. kSetupRecTypeNum                EQU        12                    ; "Setup" 
  65. kMSAMRecTypeNum                    EQU        13                    ; "MSAM" 
  66. kDSAMRecTypeNum                    EQU        14                    ; "DSAM" 
  67. kAttributeValueRecTypeNum        EQU        15                    ; "Attribute Value" 
  68. kBusinessCardRecTypeNum            EQU        16                    ; "Business Card" 
  69. kMailServiceRecTypeNum            EQU        17                    ; "Mail Service" 
  70. kCombinedRecTypeNum                EQU        18                    ; "Combined" 
  71. kOtherServiceRecTypeNum            EQU        19                    ; "Other Service" 
  72. kAFPServiceRecTypeNum            EQU        20                    ; "Other Service afps" 
  73. kFirstOCERecTypeNum                EQU        1                    ; first standard OCE record type 
  74. kLastOCERecTypeNum                EQU        20                    ; last standard OCE record type 
  75. kNumOCERecTypes                    EQU        20
  76. ;  Indices for the standard definitions for certain attribute types (OCEAttributeTypeIndex): 
  77.  
  78. kMemberAttrTypeNum                EQU        1001                ; "Member" 
  79. kAdminsAttrTypeNum                EQU        1002                ; "Administrators" 
  80. kMailSlotsAttrTypeNum            EQU        1003                ; "mailslots" 
  81. kPrefMailAttrTypeNum            EQU        1004                ; "pref mailslot" 
  82. kAddressAttrTypeNum                EQU        1005                ; "Address" 
  83. kPictureAttrTypeNum                EQU        1006                ; "Picture" 
  84. kAuthKeyAttrTypeNum                EQU        1007                ; "auth key" 
  85. kTelephoneAttrTypeNum            EQU        1008                ; "Telephone" 
  86. kNBPNameAttrTypeNum                EQU        1009                ; "NBP Name" 
  87. kQMappingAttrTypeNum            EQU        1010                ; "ForwarderQMap" 
  88. kDialupSlotAttrTypeNum            EQU        1011                ; "DialupSlotInfo" 
  89. kHomeNetAttrTypeNum                EQU        1012                ; "Home Internet" 
  90. kCoResAttrTypeNum                EQU        1013                ; "Co-resident M&M" 
  91. kFwdrLocalAttrTypeNum            EQU        1014                ; "FwdrLocalRecord" 
  92. kConnectAttrTypeNum                EQU        1015                ; "Connected To" 
  93. kForeignAttrTypeNum                EQU        1016                ; "Foreign RLIs" 
  94. kOwnersAttrTypeNum                EQU        1017                ; "Owners" 
  95. kReadListAttrTypeNum            EQU        1018                ; "ReadList" 
  96. kWriteListAttrTypeNum            EQU        1019                ; "WriteList" 
  97. kDescriptorAttrTypeNum            EQU        1020                ; "Descriptor" 
  98. kCertificateAttrTypeNum            EQU        1021                ; "Certificate" 
  99. kMsgQsAttrTypeNum                EQU        1022                ; "MessageQs" 
  100. kPrefMsgQAttrTypeNum            EQU        1023                ; "PrefMessageQ" 
  101. kMasterPFAttrTypeNum            EQU        1024                ; "MasterPF" 
  102. kMasterNetSpecAttrTypeNum        EQU        1025                ; "MasterNetSpec" 
  103. kServersOfAttrTypeNum            EQU        1026                ; "Servers Of" 
  104. kParentCIDAttrTypeNum            EQU        1027                ; "Parent CID" 
  105. kNetworkSpecAttrTypeNum            EQU        1028                ; "NetworkSpec" 
  106. kLocationAttrTypeNum            EQU        1029                ; "Location" 
  107. kTimeSvrTypeAttrTypeNum            EQU        1030                ; "TimeServer Type" 
  108. kUpdateTimerAttrTypeNum            EQU        1031                ; "Update Timer" 
  109. kShadowsOfAttrTypeNum            EQU        1032                ; "Shadows Of" 
  110. kShadowServerAttrTypeNum        EQU        1033                ; "Shadow Server" 
  111. kTBSetupAttrTypeNum                EQU        1034                ; "TB Setup" 
  112. kMailSetupAttrTypeNum            EQU        1035                ; "Mail Setup" 
  113. kSlotIDAttrTypeNum                EQU        1036                ; "SlotID" 
  114. kGatewayFileIDAttrTypeNum        EQU        1037                ; "Gateway FileID" 
  115. kMailServiceAttrTypeNum            EQU        1038                ; "Mail Service" 
  116. kStdSlotInfoAttrTypeNum            EQU        1039                ; "Std Slot Info" 
  117. kAssoDirectoryAttrTypeNum        EQU        1040                ; "Asso. Directory" 
  118. kDirectoryAttrTypeNum            EQU        1041                ; "Directory" 
  119. kDirectoriesAttrTypeNum            EQU        1042                ; "Directories" 
  120. kSFlagsAttrTypeNum                EQU        1043                ; "SFlags" 
  121. kLocalNameAttrTypeNum            EQU        1044                ; "Local Name" 
  122. kLocalKeyAttrTypeNum            EQU        1045                ; "Local Key" 
  123. kDirUserRIDAttrTypeNum            EQU        1046                ; "Dir User RID" 
  124. kDirUserKeyAttrTypeNum            EQU        1047                ; "Dir User Key" 
  125. kDirNativeNameAttrTypeNum        EQU        1048                ; "Dir Native Name" 
  126. kCommentAttrTypeNum                EQU        1049                ; "Comment" 
  127. kRealNameAttrTypeNum            EQU        1050                ; "Real Name" 
  128. kPrivateDataAttrTypeNum            EQU        1051                ; "Private Data" 
  129. kDirTypeAttrTypeNum                EQU        1052                ; "Directory Type" 
  130. kDSAMFileAliasAttrTypeNum        EQU        1053                ; "DSAM File Alias" 
  131. kCanAddressToAttrTypeNum        EQU        1054                ; "Can Address To" 
  132. kDiscriminatorAttrTypeNum        EQU        1055                ; "Discriminator" 
  133. kAliasAttrTypeNum                EQU        1056                ; "Alias" 
  134. kParentMSAMAttrTypeNum            EQU        1057                ; "Parent MSAM" 
  135. kParentDSAMAttrTypeNum            EQU        1058                ; "Parent DSAM" 
  136. kSlotAttrTypeNum                EQU        1059                ; "Slot" 
  137. kAssoMailServiceAttrTypeNum        EQU        1060                ; "Asso. Mail Service" 
  138. kFakeAttrTypeNum                EQU        1061                ; "Fake" 
  139. kInheritSysAdminAttrTypeNum        EQU        1062                ; "Inherit SysAdministrators" 
  140. kPreferredPDAttrTypeNum            EQU        1063                ; "Preferred PD" 
  141. kLastLoginAttrTypeNum            EQU        1064                ; "Last Login" 
  142. kMailerAOMStateAttrTypeNum        EQU        1065                ; "Mailer AOM State" 
  143. kMailerSendOptionsAttrTypeNum    EQU        1066                ; "Mailer Send Options" 
  144. kJoinedAttrTypeNum                EQU        1067                ; "Joined" 
  145. kUnconfiguredAttrTypeNum        EQU        1068                ; "Unconfigured" 
  146. kVersionAttrTypeNum                EQU        1069                ; "Version" 
  147. kLocationNamesAttrTypeNum        EQU        1070                ; "Location Names" 
  148. kActiveAttrTypeNum                EQU        1071                ; "Active" 
  149. kDeleteRequestedAttrTypeNum        EQU        1072                ; "Delete Requested" 
  150. kGatewayTypeAttrTypeNum            EQU        1073                ; "Gateway Type" 
  151. kFirstOCEAttrTypeNum            EQU        1001                ; first standard OCE attr type 
  152. kLastOCEAttrTypeNum                EQU        1073                ; last standard OCE attr type 
  153. kNumOCEAttrTypes                EQU        73
  154.     ENDIF
  155.     IF FOR_SYSTEM7_ONLY THEN
  156. ;  Miscellaneous enums: 
  157.  
  158. kRString32Size                    EQU        32                    ; max size of the body field in RString32 
  159. kRString64Size                    EQU        64                    ; max size of the body field in RString64 
  160. kNetworkSpecMaxBytes            EQU        32                    ; max size of the body field in NetworkSpec 
  161. kPathNameMaxBytes                EQU        1024                ; max size of the data field in PackedPathName 
  162. kDirectoryNameMaxBytes            EQU        32                    ; max size of the body field in DirectoryName 
  163. kAttributeTypeMaxBytes            EQU        32                    ; max size of the body field in AttributeType 
  164. kAttrValueMaxBytes                EQU        65536                ; max size of any attribute value 
  165. kRStringMaxBytes                EQU        256                    ; max size (in bytes) of the body field of a recordName or recordType 
  166. kRStringMaxChars                EQU        128                    ; max size (in chars) of the body field of a recordName or recordType 
  167.  
  168. kNULLDNodeNumber                EQU        0                    ; Special value meaning none specified 
  169. kRootDNodeNumber                EQU        2                    ; DNodeNum corresponding to the root of the tree 
  170. ;
  171. ; This enum is used to select the kind of RString in calls such as OCERelRString,
  172. ;OCEEqualRString, and OCEValidRString.
  173. ;
  174. ;eGenericSensitive and eGenericInsensitive are enumerators that can be used if you
  175. ;use RStrings for things other than what you see in this file.  If you want them to
  176. ;be compared in a case- and diacritical-sensitive manner (c ≠ C ≠ ç), use
  177. ;eGenericSensitive.  If you want them to be compared in a case- and diacritical-
  178. ;insensitive manner (c = C = ç), use eGenericInensitive.
  179. ;WARNING:  do not use eGenericSensitive and eGenericInsensitive with catalog
  180. ;names, entity names, pathname parts, entity types, network specs, or attribute
  181. ;types!  Don't assume that you know how they should be compared!!! 
  182. ;
  183.  
  184. kOCEDirName                        EQU        0
  185. kOCERecordOrDNodeName            EQU        1
  186. kOCERecordType                    EQU        2
  187. kOCENetworkSpec                    EQU        3
  188. kOCEAttrType                    EQU        4
  189. kOCEGenericSensitive            EQU        5
  190. kOCEGenericInsensitive            EQU        6
  191. ; typedef unsigned short                 RStringKind
  192.  
  193. ;  Values for the signature field in Discriminator 
  194.  
  195. kDirAllKinds                    EQU        0
  196. kDirADAPKind                    EQU        'adap'
  197. kDirPersonalDirectoryKind        EQU        'pdir'
  198. kDirDSAMKind                    EQU        'dsam'
  199. ; typedef unsigned long                 OCEDirectoryKind
  200.  
  201. ;  Values returned by GetDSSpecInfo() 
  202.  
  203. kOCEInvalidDSSpec                EQU        $3F3F3F3F            ; '????' could not be determined 
  204. kOCEDirsRootDSSpec                EQU        'root'                ; root of all catalogs ("Catalogs" icon) 
  205. kOCEDirectoryDSSpec                EQU        'dire'                ; catalog 
  206. kOCEDNodeDSSpec                    EQU        'dnod'                ; d-node 
  207. kOCERecordDSSpec                EQU        'reco'                ; record 
  208. kOCEentnDSSpec                    EQU        'entn'                ; extensionType is 'entn' 
  209. kOCENOTentnDSSpec                EQU        'not '                ; extensionType is not 'entn' 
  210. ;  Values for AttributeTag 
  211.  
  212. typeRString                        EQU        'rstr'
  213. typePackedDSSpec                EQU        'dspc'
  214. typeBinary                        EQU        'bnry'
  215. ;
  216. ; Bit flag corresponding to the canContainRecords bit.  Use it like this:
  217. ;    if (foo & kCanContainRecords)
  218. ;        then this dNode can contain records!
  219. ;kForeignNode is used to indicate nodes in the name hierarchy that correspond to
  220. ;foreign catalogs (meaning ADAP sees no clusters or DNodes beneath it, but
  221. ;mail routers might be able to route to clusters beneath it. 
  222. ;
  223.  
  224. kCanContainRecordsBit            EQU        0
  225. kForeignNodeBit                    EQU        1
  226. ;  DirNodeKind 
  227.  
  228. kCanContainRecords                EQU        $00000001
  229. kForeignNode                    EQU        $00000002
  230. ; typedef unsigned long                 DirNodeKind
  231.  
  232. ; *** Toolbox Control ***
  233. ;
  234. ; We will have a version number and attributes for toolboxes off the aa5e trap
  235. ;and the S&F server trap.
  236. ;
  237. ;This includes the OCE toolbox and S&F Server.  [Note: the S&F server will
  238. ;change to ONLY service ServerGateway calls —it will then be necessary to run
  239. ;it co–resident with an OCE toolbox].
  240. ;
  241. ;The high order word will represent the S&F Server version number.  The low
  242. ;order word will represent the OCE toolbox version number.  These will be zero
  243. ;until the component is up and running.  It is not possible to know these
  244. ;a–priori. Note: there will not be a seperate version numbers for each component
  245. ;in the OCE toolbox or S&F server.
  246. ;
  247. ;The above is consistent with the standard System 7.0 usage of Gestalt.
  248. ;
  249. ;The oce tb attribute gestaltOCETBPresent implies the existence of OCE on a
  250. ;machine.
  251. ;
  252. ;The OCE TB attribute gestaltOCETBAvailable implies the availablity of OCE calls.
  253. ;
  254. ;The attribute gestaltOCESFServerAvailable implies the availablity of OCE calls
  255. ;available through the S&F server. This are essentially the server gateway calls.
  256. ;
  257. ;Any (future) remaining OCE attributes may not be established correctly until
  258. ;the attribute gestaltOCETBAvailable is set.
  259. ;
  260. ;The gestalt selectors and values are listed below: 
  261. ;
  262.  
  263. gestaltOCEToolboxVersion        EQU        'ocet'                ; OCE Toolbox version 
  264. gestaltOCEToolboxAttr            EQU        'oceu'                ; OCE Toolbox attributes 
  265. ;
  266. ; version includes:
  267. ; *  dirtb
  268. ; *  authtb
  269. ; *  mailtb
  270. ; *  ipmtb
  271. ; *  personal catalog
  272. ; *  ADSPSecure
  273. ; * e.g. all interfaces dependent on the aa5e trap. 
  274. ;
  275.  
  276. gestaltOCETB                    EQU        $0102                ; OCE Toolbox version 1.02 
  277. gestaltSFServer                    EQU        $0100                ; S&F Server version 1.0 
  278. gestaltOCETBPresent                EQU        $01                    ; OCE toolbox is present, not running 
  279. gestaltOCETBAvailable            EQU        $02                    ; OCE toolbox is running and available 
  280. gestaltOCESFServerAvailable        EQU        $04                    ; S&F Server is running and available 
  281. gestaltOCETBNativeGlueAvailable    EQU        $10                    ; Native PowerPC Glue routines are availible 
  282. ;     Constants used for Transitions. 
  283.  
  284. ATTransIPMStart                    EQU        'ipms'
  285. ATTransIPMShutdown                EQU        'ipmd'
  286. ATTransDirStart                    EQU        'dirs'
  287. ATTransDirShutdown                EQU        'dird'
  288. ATTransAuthStart                EQU        'auts'
  289. ATTransAuthShutdown                EQU        'autd'
  290. ATTransSFStart                    EQU        's&fs'
  291. ATTransSFShutdown                EQU        's&fd'
  292. ;  Some definitions for time-related parameters: 
  293. ;  Interpreted as UTC seconds since 1/1/1904 
  294. ; typedef unsigned long                 UTCTime
  295.  
  296. ;  seconds EAST of Greenwich 
  297. ; typedef long                             UTCOffset
  298.  
  299. ;  This is the same as the ScriptManager script. 
  300. ; typedef short                         CharacterSet
  301.  
  302. ; *** RString ***
  303. ;
  304. ; struct RString is a maximum-sized structure.  Allocate one of these and it will
  305. ;hold any valid RString. 
  306. ;
  307. RString                    RECORD 0
  308. charSet                     ds.w    1                ; offset: $0 (0)
  309. dataLength                 ds.w    1                ; offset: $2 (2)
  310. body                     ds.b    256                ; offset: $4 (4)        ;  place for characters 
  311. sizeof                     EQU *                    ; size:   $104 (260)
  312.                         ENDR
  313. ;  struct ProtoRString is a minimum-sized structure.  Use this for a variable-length RString. 
  314. ProtoRString            RECORD 0
  315. charSet                     ds.w    1                ; offset: $0 (0)
  316. dataLength                 ds.w    1                ; offset: $2 (2)
  317. sizeof                     EQU *                    ; size:   $4 (4)
  318.                         ENDR
  319. ; typedef struct RString *                RStringPtr
  320.  
  321. ; typedef RStringPtr *                    RStringHandle
  322.  
  323. ; typedef struct ProtoRString *            ProtoRStringPtr
  324.  
  325. RString64                RECORD 0
  326. charSet                     ds.w    1                ; offset: $0 (0)
  327. dataLength                 ds.w    1                ; offset: $2 (2)
  328. body                     ds.b    64                ; offset: $4 (4)
  329. sizeof                     EQU *                    ; size:   $44 (68)
  330.                         ENDR
  331. RString32                RECORD 0
  332. charSet                     ds.w    1                ; offset: $0 (0)
  333. dataLength                 ds.w    1                ; offset: $2 (2)
  334. body                     ds.b    32                ; offset: $4 (4)
  335. sizeof                     EQU *                    ; size:   $24 (36)
  336.                         ENDR
  337. ;
  338. ; Standard definitions for the entity type field and attribute type
  339. ;have been moved to the end of the file. 
  340. ;
  341. ;
  342. ; Copies str1 to str2.  str2Length is the size of str2, excluding header.
  343. ;A memFull error will be returned if that is not as large as str1->dataLength. 
  344. ;
  345. ;
  346. ; pascal OSErr OCECopyRString(const RString *str1, RString *str2, unsigned short str2Length)
  347. ;
  348.     IF ¬ GENERATINGCFM THEN
  349.         Macro
  350.         _OCECopyRString
  351.             move.w              #$0308,D0
  352.             dc.w                $AA5C
  353.         EndM
  354.     ELSE
  355.         IMPORT_CFM_FUNCTION OCECopyRString
  356.     ENDIF
  357.  
  358. ;
  359. ;    Make an RString from a C string.  If the c string is bigger than rStrLength,
  360. ;only rStrLength bytes will be copied. (rStrLength does not include the header size) 
  361. ;
  362. ;
  363. ; pascal void OCECToRString(const char *cStr, CharacterSet charSet, RString *rStr, unsigned short rStrLength)
  364. ;
  365.     IF ¬ GENERATINGCFM THEN
  366.         Macro
  367.         _OCECToRString
  368.             move.w              #$0339,D0
  369.             dc.w                $AA5C
  370.         EndM
  371.     ELSE
  372.         IMPORT_CFM_FUNCTION OCECToRString
  373.     ENDIF
  374.  
  375. ;
  376. ;    Make an RString from a Pascal string.  If the Pascal string is bigger than rStrLength,
  377. ;only rStrLength bytes will be copied. (rStrLength does not include the header size) 
  378. ;
  379. ;
  380. ; pascal void OCEPToRString(ConstStr255Param pStr, CharacterSet charSet, RString *rStr, unsigned short rStrLength)
  381. ;
  382.     IF ¬ GENERATINGCFM THEN
  383.         Macro
  384.         _OCEPToRString
  385.             move.w              #$033A,D0
  386.             dc.w                $AA5C
  387.         EndM
  388.     ELSE
  389.         IMPORT_CFM_FUNCTION OCEPToRString
  390.     ENDIF
  391.  
  392. ;
  393. ;    Make a Pascal string from an RString.  It's up to you to check the char set of
  394. ;the RString, or if the length of the RString is greater than 255 (the Pascal string's
  395. ;length will simply be the lower byte of the RString's length).  The StringPtr that is
  396. ;returned will point directly into the RString (no memory will be allocated). 
  397. ;
  398. ;
  399. ; pascal StringPtr OCERToPString(const RString *rStr)
  400. ;
  401.     IF ¬ GENERATINGCFM THEN
  402.         Macro
  403.         _OCERToPString
  404.             move.w              #$033B,D0
  405.             dc.w                $AA5C
  406.         EndM
  407.     ELSE
  408.         IMPORT_CFM_FUNCTION OCERToPString
  409.     ENDIF
  410.  
  411. ;
  412. ;    Check the relative equality of two RStrings.  Determines if str1 is greater than,
  413. ;equal to, or less than str2.  Result types for OCERelRString are defined in <OSUtils.h>
  414. ;(same as for RelString). 
  415. ;
  416. ;
  417. ; pascal short OCERelRString(const void *str1, const void *str2, RStringKind kind)
  418. ;
  419.     IF ¬ GENERATINGCFM THEN
  420.         Macro
  421.         _OCERelRString
  422.             move.w              #$032D,D0
  423.             dc.w                $AA5C
  424.         EndM
  425.     ELSE
  426.         IMPORT_CFM_FUNCTION OCERelRString
  427.     ENDIF
  428.  
  429. ;     Check for equality of two RStrings. Returns true if equal. 
  430. ;
  431. ; pascal Boolean OCEEqualRString(const void *str1, const void *str2, RStringKind kind)
  432. ;
  433.     IF ¬ GENERATINGCFM THEN
  434.         Macro
  435.         _OCEEqualRString
  436.             move.w              #$0316,D0
  437.             dc.w                $AA5C
  438.         EndM
  439.     ELSE
  440.         IMPORT_CFM_FUNCTION OCEEqualRString
  441.     ENDIF
  442.  
  443. ;     Check the validity of an RString.  Returns true if the RString is valid 
  444. ;
  445. ; pascal Boolean OCEValidRString(const void *str, RStringKind kind)
  446. ;
  447.     IF ¬ GENERATINGCFM THEN
  448.         Macro
  449.         _OCEValidRString
  450.             move.w              #$0338,D0
  451.             dc.w                $AA5C
  452.         EndM
  453.     ELSE
  454.         IMPORT_CFM_FUNCTION OCEValidRString
  455.     ENDIF
  456.  
  457. ; *** CreationID ***
  458. CreationID                RECORD 0
  459. source                     ds.l    1                ; offset: $0 (0)        ;  Fields definitions and usage are not defined 
  460. seq                         ds.l    1                ; offset: $4 (4)
  461. sizeof                     EQU *                    ; size:   $8 (8)
  462.                         ENDR
  463. AttributeCreationID        RECORD 0
  464. f                         ds        CreationID
  465. sizeof                     EQU *                    ; size:   $8 (8)
  466.                         ENDR
  467.  
  468.  
  469. ; typedef struct CreationID *            CreationIDPtr
  470.  
  471. ;  Returns a pointer to a null CreationID . 
  472. ;
  473. ; pascal const CreationID *OCENullCID(void )
  474. ;
  475.     IF ¬ GENERATINGCFM THEN
  476.         Macro
  477.         _OCENullCID
  478.             move.w              #$0344,D0
  479.             dc.w                $AA5C
  480.         EndM
  481.     ELSE
  482.         IMPORT_CFM_FUNCTION OCENullCID
  483.     ENDIF
  484.  
  485. ;  Returns a pointer to a special CreationID used within the PathFinder. 
  486. ;
  487. ; pascal const CreationID *OCEPathFinderCID(void )
  488. ;
  489.     IF ¬ GENERATINGCFM THEN
  490.         Macro
  491.         _OCEPathFinderCID
  492.             move.w              #$033C,D0
  493.             dc.w                $AA5C
  494.         EndM
  495.     ELSE
  496.         IMPORT_CFM_FUNCTION OCEPathFinderCID
  497.     ENDIF
  498.  
  499. ;  Sets the CreationID to a null value. 
  500. ;
  501. ; pascal void OCESetCreationIDtoNull(CreationID *cid)
  502. ;
  503.     IF ¬ GENERATINGCFM THEN
  504.         Macro
  505.         _OCESetCreationIDtoNull
  506.             move.w              #$032E,D0
  507.             dc.w                $AA5C
  508.         EndM
  509.     ELSE
  510.         IMPORT_CFM_FUNCTION OCESetCreationIDtoNull
  511.     ENDIF
  512.  
  513. ;  Copies the value of cid1 to cid2. 
  514. ;
  515. ; pascal void OCECopyCreationID(const CreationID *cid1, CreationID *cid2)
  516. ;
  517.     IF ¬ GENERATINGCFM THEN
  518.         Macro
  519.         _OCECopyCreationID
  520.             move.w              #$0300,D0
  521.             dc.w                $AA5C
  522.         EndM
  523.     ELSE
  524.         IMPORT_CFM_FUNCTION OCECopyCreationID
  525.     ENDIF
  526.  
  527. ;  Check the equality of two CreationIDs. 
  528. ;
  529. ; pascal Boolean OCEEqualCreationID(const CreationID *cid1, const CreationID *cid2)
  530. ;
  531.     IF ¬ GENERATINGCFM THEN
  532.         Macro
  533.         _OCEEqualCreationID
  534.             move.w              #$030C,D0
  535.             dc.w                $AA5C
  536.         EndM
  537.     ELSE
  538.         IMPORT_CFM_FUNCTION OCEEqualCreationID
  539.     ENDIF
  540.  
  541. ; *** NetworkSpec ***
  542. ;
  543. ; For the record, a NetworkSpec is an RString with a smaller maximum size.
  544. ;I don't just typedef it to an RString, because I want the definition of the NetworkSpec
  545. ;struct to contain the max length.  But it should be possible to typecast any
  546. ;NetworkSpec to an RString and use all the RString utilities on it. 
  547. ;
  548. NetworkSpec                RECORD 0
  549. charSet                     ds.w    1                ; offset: $0 (0)
  550. dataLength                 ds.w    1                ; offset: $2 (2)
  551. body                     ds.b    32                ; offset: $4 (4)        ;  always fixed at the max size 
  552. sizeof                     EQU *                    ; size:   $24 (36)
  553.                         ENDR
  554. ; typedef struct NetworkSpec *            NetworkSpecPtr
  555.  
  556. ; *** PackedPathName ***
  557. ;
  558. ; struct PackedPathName is a maximum-sized structure.  Allocate one of
  559. ;these and it will hold any valid packed pathname. 
  560. ;
  561. PackedPathName            RECORD 0
  562. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  563. data                     ds.b    1022            ; offset: $2 (2)
  564. sizeof                     EQU *                    ; size:   $400 (1024)
  565.                         ENDR
  566. ;
  567. ; struct ProtoPackedPathName is a minimum-sized structure.  Use this
  568. ;for a variable-length packed PathName. 
  569. ;
  570. ProtoPackedPathName        RECORD 0
  571. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  572. ;  Followed by data 
  573. sizeof                     EQU *                    ; size:   $2 (2)
  574.                         ENDR
  575. ; typedef struct PackedPathName *        PackedPathNamePtr
  576.  
  577. ; typedef struct ProtoPackedPathName *    ProtoPackedPathNamePtr
  578.  
  579. ;
  580. ;Copy the contents of path1 to path2.  path2Length is the size of path2, and must
  581. ;be large enough to hold a copy of path1.  A memFull error will be returned if that
  582. ;is not the case.
  583. ;
  584. ;
  585. ; pascal OSErr OCECopyPackedPathName(const PackedPathName *path1, PackedPathName *path2, unsigned short path2Length)
  586. ;
  587.     IF ¬ GENERATINGCFM THEN
  588.         Macro
  589.         _OCECopyPackedPathName
  590.             move.w              #$0304,D0
  591.             dc.w                $AA5C
  592.         EndM
  593.     ELSE
  594.         IMPORT_CFM_FUNCTION OCECopyPackedPathName
  595.     ENDIF
  596.  
  597. ;
  598. ;Returns true if packed path pointer is nil, or is of zero length, or is of
  599. ;length 2 and nParts of zero.
  600. ;
  601. ;
  602. ; pascal Boolean OCEIsNullPackedPathName(const PackedPathName *path)
  603. ;
  604.     IF ¬ GENERATINGCFM THEN
  605.         Macro
  606.         _OCEIsNullPackedPathName
  607.             move.w              #$031D,D0
  608.             dc.w                $AA5C
  609.         EndM
  610.     ELSE
  611.         IMPORT_CFM_FUNCTION OCEIsNullPackedPathName
  612.     ENDIF
  613.  
  614. ;
  615. ;OCEUnpackPathName breaks apart the path into its component RStrings, writing string
  616. ;pointers into the array 'parts', which the client asserts can hold as many as
  617. ;'nParts' elements. The number of parts actually found is returned.  Strings are
  618. ;placed in the array in order from lowest to highest.  The first pathName element
  619. ;beneath the root appears last.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO
  620. ;THE PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  621. ;WITH THE UNPACKED STRUCT AS WELL
  622. ;
  623. ;
  624. ; pascal unsigned short OCEUnpackPathName(const PackedPathName *path, RStringPtr *parts, unsigned short nParts)
  625. ;
  626.     IF ¬ GENERATINGCFM THEN
  627.         Macro
  628.         _OCEUnpackPathName
  629.             move.w              #$0330,D0
  630.             dc.w                $AA5C
  631.         EndM
  632.     ELSE
  633.         IMPORT_CFM_FUNCTION OCEUnpackPathName
  634.     ENDIF
  635.  
  636. ;
  637. ;OCEPackedPathNameSize computes the number of bytes of memory needed to hold a
  638. ;PackedPathName manufactured from the array of parts.  This length
  639. ;includes the length of the length field of PackedPathName, so it
  640. ;is safe to do a NewPtr (OCEPackedPathNameSize(...)).
  641. ;
  642. ;
  643. ; pascal unsigned short OCEPackedPathNameSize(const RStringPtr *parts, unsigned short nParts)
  644. ;
  645.     IF ¬ GENERATINGCFM THEN
  646.         Macro
  647.         _OCEPackedPathNameSize
  648.             move.w              #$0328,D0
  649.             dc.w                $AA5C
  650.         EndM
  651.     ELSE
  652.         IMPORT_CFM_FUNCTION OCEPackedPathNameSize
  653.     ENDIF
  654.  
  655. ;  OCEDNodeNameCount returns the number of RStrings contained within the path. 
  656. ;
  657. ; pascal unsigned short OCEDNodeNameCount(const PackedPathName *path)
  658. ;
  659.     IF ¬ GENERATINGCFM THEN
  660.         Macro
  661.         _OCEDNodeNameCount
  662.             move.w              #$032C,D0
  663.             dc.w                $AA5C
  664.         EndM
  665.     ELSE
  666.         IMPORT_CFM_FUNCTION OCEDNodeNameCount
  667.     ENDIF
  668.  
  669. ;
  670. ;OCEPackPathName packs the parts into the storage provided as 'path'.  path must be
  671. ;large enough to hold the packed pathname.  A memFull error will be returned if
  672. ;pathLength is too small.  parts[0] should contain the deepest pathName element,
  673. ;and parts[nParts - 1] should contain the name of the first pathName element beneath
  674. ;the root. 
  675. ;
  676. ;
  677. ; pascal OSErr OCEPackPathName(RStringPtr *parts, unsigned short nParts, PackedPathName *path, unsigned short pathLength)
  678. ;
  679.     IF ¬ GENERATINGCFM THEN
  680.         Macro
  681.         _OCEPackPathName
  682.             move.w              #$0323,D0
  683.             dc.w                $AA5C
  684.         EndM
  685.     ELSE
  686.         IMPORT_CFM_FUNCTION OCEPackPathName
  687.     ENDIF
  688.  
  689. ;
  690. ;Check the equality of two packed paths.
  691. ;
  692. ;
  693. ; pascal Boolean OCEEqualPackedPathName(const PackedPathName *path1, const PackedPathName *path2)
  694. ;
  695.     IF ¬ GENERATINGCFM THEN
  696.         Macro
  697.         _OCEEqualPackedPathName
  698.             move.w              #$0311,D0
  699.             dc.w                $AA5C
  700.         EndM
  701.     ELSE
  702.         IMPORT_CFM_FUNCTION OCEEqualPackedPathName
  703.     ENDIF
  704.  
  705. ;
  706. ;OCEValidPackedPathName checks that the packed PathName is internally consistent.
  707. ;Returns true if it's ok.
  708. ;
  709. ;
  710. ; pascal Boolean OCEValidPackedPathName(const PackedPathName *path)
  711. ;
  712.     IF ¬ GENERATINGCFM THEN
  713.         Macro
  714.         _OCEValidPackedPathName
  715.             move.w              #$0334,D0
  716.             dc.w                $AA5C
  717.         EndM
  718.     ELSE
  719.         IMPORT_CFM_FUNCTION OCEValidPackedPathName
  720.     ENDIF
  721.  
  722. ; *** DirDiscriminator ***
  723. DirDiscriminator        RECORD 0
  724. signature                 ds.l    1                ; offset: $0 (0)
  725. misc                     ds.l    1                ; offset: $4 (4)
  726. sizeof                     EQU *                    ; size:   $8 (8)
  727.                         ENDR
  728. ;  Copies the value of disc1 to disc2. 
  729. ;
  730. ; pascal void OCECopyDirDiscriminator(const DirDiscriminator *disc1, DirDiscriminator *disc2)
  731. ;
  732.     IF ¬ GENERATINGCFM THEN
  733.         Macro
  734.         _OCECopyDirDiscriminator
  735.             move.w              #$0301,D0
  736.             dc.w                $AA5C
  737.         EndM
  738.     ELSE
  739.         IMPORT_CFM_FUNCTION OCECopyDirDiscriminator
  740.     ENDIF
  741.  
  742. ;  Check the equality of two DirDiscriminators. 
  743. ;
  744. ; pascal Boolean OCEEqualDirDiscriminator(const DirDiscriminator *disc1, const DirDiscriminator *disc2)
  745. ;
  746.     IF ¬ GENERATINGCFM THEN
  747.         Macro
  748.         _OCEEqualDirDiscriminator
  749.             move.w              #$030D,D0
  750.             dc.w                $AA5C
  751.         EndM
  752.     ELSE
  753.         IMPORT_CFM_FUNCTION OCEEqualDirDiscriminator
  754.     ENDIF
  755.  
  756. ;
  757. ;This structure is called RLI because it really contains all the info you
  758. ;need to locate a record within the entire name space.  It contains four fields.
  759. ;The first two are the name of the catalog and a catalog discriminator.  These
  760. ;two fields are used to indicate to which catalog a given record belongs.  The
  761. ;discriminator is used to distinguish between two different catalogs that have
  762. ;the same name.
  763. ;
  764. ;The other two fields in the RLI structure are used to indicate a particular
  765. ;catalog node within the catalog specified by the directoryName and
  766. ;discriminator fields.  These fields are exactly analagous to the dirID and
  767. ;pathname used in HFS.  It is possible to specify a dNode just by dNodeNumber
  768. ;(pathname is nil), or just by pathname (dNodeNumber is set to kNULLDNodeNumber),
  769. ;or by a combination of the two.  The latter is called a 'partial pathname', and
  770. ;while it is valid in the Catalog Manager API, it is not supported by ADAP
  771. ;catalogs in Release 1.
  772. ;
  773. ;Note that the path parameter does not include the catalog name, but holds
  774. ;the names of all the nodes on the path to the desired catalog node, starting
  775. ;with the catalog node and working its way up the tree.
  776. ;
  777. ; *** RLI ***
  778. DirectoryName            RECORD 0
  779. charSet                     ds.w    1                ; offset: $0 (0)
  780. dataLength                 ds.w    1                ; offset: $2 (2)
  781. body                     ds.b    32                ; offset: $4 (4)        ;  space for catalog name 
  782. sizeof                     EQU *                    ; size:   $24 (36)
  783.                         ENDR
  784. ; typedef struct DirectoryName *        DirectoryNamePtr
  785.  
  786. ;  Catalog node number 
  787. ; typedef unsigned long                 DNodeNum
  788.  
  789. RLI                        RECORD 0
  790. directoryName             ds.l    1                ; offset: $0 (0)        ;  pointer to the name of the catalog root 
  791. discriminator             ds        DirDiscriminator ; offset: $4 (4)        ;  used to discriminate between dup catalog names 
  792. dNodeNumber                 ds.l    1                ; offset: $C (12)        ;  number of the node 
  793. path                     ds.l    1                ; offset: $10 (16)        ;  old-style RLI 
  794. sizeof                     EQU *                    ; size:   $14 (20)
  795.                         ENDR
  796. ; typedef struct RLI *                    RLIPtr
  797.  
  798. ;
  799. ;Create a new RLI from the catalog name, discriminator, DNode number, and
  800. ;PackedPathName.  You must allocate the storage for the RLI and pass in a pointer
  801. ;to it.
  802. ;
  803. ;
  804. ; pascal void OCENewRLI(RLI *newRLI, const DirectoryName *dirName, DirDiscriminator *discriminator, DNodeNum dNodeNumber, const PackedPathName *path)
  805. ;
  806.     IF ¬ GENERATINGCFM THEN
  807.         Macro
  808.         _OCENewRLI
  809.             move.w              #$031F,D0
  810.             dc.w                $AA5C
  811.         EndM
  812.     ELSE
  813.         IMPORT_CFM_FUNCTION OCENewRLI
  814.     ENDIF
  815.  
  816. ;
  817. ;Duplicate the contents of rli1 to rli2.  No errors are returned. This
  818. ;simply copies the pointers to the catalog name and path, wiping out any pointer
  819. ;that you might have had in there.
  820. ;
  821. ;
  822. ; pascal void OCEDuplicateRLI(const RLI *rli1, RLI *rli2)
  823. ;
  824.     IF ¬ GENERATINGCFM THEN
  825.         Macro
  826.         _OCEDuplicateRLI
  827.             move.w              #$030B,D0
  828.             dc.w                $AA5C
  829.         EndM
  830.     ELSE
  831.         IMPORT_CFM_FUNCTION OCEDuplicateRLI
  832.     ENDIF
  833.  
  834. ;
  835. ;Copy the contents of rli1 to rli2.  rli2 must already contain
  836. ;pointers to structures large enough to hold copies of the corresponding
  837. ;fields from rli1.  A memFull error will be returned if that is not the case.
  838. ;So if you allocate a brand new empty destination, you must at least set up
  839. ;its length fields.
  840. ;
  841. ;
  842. ; pascal OSErr OCECopyRLI(const RLI *rli1, RLI *rli2)
  843. ;
  844.     IF ¬ GENERATINGCFM THEN
  845.         Macro
  846.         _OCECopyRLI
  847.             move.w              #$0307,D0
  848.             dc.w                $AA5C
  849.         EndM
  850.     ELSE
  851.         IMPORT_CFM_FUNCTION OCECopyRLI
  852.     ENDIF
  853.  
  854. ;
  855. ;Check the equality of two RLIs.  This will take into account differences
  856. ;in the case and diacriticals of the directoryName and the PathName.
  857. ;NOTE THAT THIS WILL FAIL IF rli1 CONTAINS A DNODENUMBER AND A NIL PATHNAME,
  858. ;AND rli2 CONTAINS kNULLDNodeNumber AND A NON-NIL PATHNAME.  IN OTHER WORDS,
  859. ;THE TWO rlis MUST BE OF THE SAME FORM TO CHECK FOR EQUALITY.
  860. ;The one exception is that if the pathname is nil, a dNodeNumber of zero and
  861. ;kRootDNodeNumber will be treated as equal.
  862. ;
  863. ;
  864. ; pascal Boolean OCEEqualRLI(const RLI *rli1, const RLI *rli2)
  865. ;
  866.     IF ¬ GENERATINGCFM THEN
  867.         Macro
  868.         _OCEEqualRLI
  869.             move.w              #$0315,D0
  870.             dc.w                $AA5C
  871.         EndM
  872.     ELSE
  873.         IMPORT_CFM_FUNCTION OCEEqualRLI
  874.     ENDIF
  875.  
  876. ;
  877. ;Check the validity of an RLI.  This checks that the catalog name length
  878. ;is within bounds, and the packed pathname (if specified) is valid.
  879. ;
  880. ;
  881. ; pascal Boolean OCEValidRLI(const RLI *theRLI)
  882. ;
  883.     IF ¬ GENERATINGCFM THEN
  884.         Macro
  885.         _OCEValidRLI
  886.             move.w              #$0337,D0
  887.             dc.w                $AA5C
  888.         EndM
  889.     ELSE
  890.         IMPORT_CFM_FUNCTION OCEValidRLI
  891.     ENDIF
  892.  
  893. ; *** PackedRLI ***
  894. ;
  895. ;struct PackedRLI is a maximum-sized structure.  Allocate one of
  896. ;these and it will hold any valid packed pathname.
  897. ;
  898.  
  899. kRLIMaxBytes                    EQU        1296
  900. PackedRLI                RECORD 0
  901. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  902. data                     ds.b    1296            ; offset: $2 (2)
  903. sizeof                     EQU *                    ; size:   $512 (1298)
  904.                         ENDR
  905. ;
  906. ;struct ProtoPackedRLI is a minimum-sized structure.  Use this
  907. ;for a variable-length packed RLI.
  908. ;
  909. ProtoPackedRLI            RECORD 0
  910. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  911. ;  Followed by data 
  912. sizeof                     EQU *                    ; size:   $2 (2)
  913.                         ENDR
  914. ; typedef struct PackedRLI *            PackedRLIPtr
  915.  
  916. ; typedef struct ProtoPackedRLI *        ProtoPackedRLIPtr
  917.  
  918. ;
  919. ;Copy the contents of prli1 to prli2.  prli2Length is the size of prli2, and must
  920. ;be large enough to hold a copy of prli1.  A memFull error will be returned if that
  921. ;is not the case.
  922. ;
  923. ;
  924. ; pascal OSErr OCECopyPackedRLI(const PackedRLI *prli1, PackedRLI *prli2, unsigned short prli2Length)
  925. ;
  926.     IF ¬ GENERATINGCFM THEN
  927.         Macro
  928.         _OCECopyPackedRLI
  929.             move.w              #$0305,D0
  930.             dc.w                $AA5C
  931.         EndM
  932.     ELSE
  933.         IMPORT_CFM_FUNCTION OCECopyPackedRLI
  934.     ENDIF
  935.  
  936. ;
  937. ;OCEUnpackRLI breaks apart the prli into its components, writing pointers into
  938. ;the rli structure.  NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE
  939. ;PACKED STRUCT - DON'T DELETE OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED
  940. ;WITH THE UNPACKED STRUCT AS WELL
  941. ;
  942. ;
  943. ; pascal void OCEUnpackRLI(const PackedRLI *prli, RLI *theRLI)
  944. ;
  945.     IF ¬ GENERATINGCFM THEN
  946.         Macro
  947.         _OCEUnpackRLI
  948.             move.w              #$0331,D0
  949.             dc.w                $AA5C
  950.         EndM
  951.     ELSE
  952.         IMPORT_CFM_FUNCTION OCEUnpackRLI
  953.     ENDIF
  954.  
  955. ;
  956. ;OCEPackedRLISize computes the number of bytes of memory needed to hold a
  957. ;PackedRLI manufactured from an RLI.  This length
  958. ;includes the length of the length field of PackedRLI, so it
  959. ;is safe to do a NewPtr (OCEPackedRLISize(...)).
  960. ;
  961. ;
  962. ; pascal unsigned short OCEPackedRLISize(const RLI *theRLI)
  963. ;
  964.     IF ¬ GENERATINGCFM THEN
  965.         Macro
  966.         _OCEPackedRLISize
  967.             move.w              #$032A,D0
  968.             dc.w                $AA5C
  969.         EndM
  970.     ELSE
  971.         IMPORT_CFM_FUNCTION OCEPackedRLISize
  972.     ENDIF
  973.  
  974. ;
  975. ;OCEPackRLI packs the RLI into the storage provided as 'prli'.  prli must be
  976. ;large enough to hold the packed RLI.  A memFull error will be returned if
  977. ;prliLength is too small.
  978. ;
  979. ;
  980. ; pascal OSErr OCEPackRLI(const RLI *theRLI, PackedRLI *prli, unsigned short prliLength)
  981. ;
  982.     IF ¬ GENERATINGCFM THEN
  983.         Macro
  984.         _OCEPackRLI
  985.             move.w              #$0324,D0
  986.             dc.w                $AA5C
  987.         EndM
  988.     ELSE
  989.         IMPORT_CFM_FUNCTION OCEPackRLI
  990.     ENDIF
  991.  
  992. ;
  993. ;OCEPackedRLIPartsSize computes the number of bytes of memory needed to hold a
  994. ;PackedRLI manufactured from the parts of an RLI.  This length
  995. ;includes the length of the length field of PackedRLI, so it
  996. ;is safe to do a NewPtr (OCEPackedRLIPartsSize(...)).
  997. ;
  998. ;
  999. ; pascal unsigned short OCEPackedRLIPartsSize(const DirectoryName *dirName, RStringPtr *parts, unsigned short nParts)
  1000. ;
  1001.     IF ¬ GENERATINGCFM THEN
  1002.         Macro
  1003.         _OCEPackedRLIPartsSize
  1004.             move.w              #$0329,D0
  1005.             dc.w                $AA5C
  1006.         EndM
  1007.     ELSE
  1008.         IMPORT_CFM_FUNCTION OCEPackedRLIPartsSize
  1009.     ENDIF
  1010.  
  1011. ;
  1012. ;OCEPackRLIParts packs the parts of an RLI into the storage provided as 'prli'.
  1013. ;prli must be large enough to hold the packed RLI.  A memFull error will be returned
  1014. ;if prliLength is too small.
  1015. ;
  1016. ;
  1017. ; pascal OSErr OCEPackRLIParts(const DirectoryName *dirName, const DirDiscriminator *discriminator, DNodeNum dNodeNumber, RStringPtr *parts, unsigned short nParts, PackedRLI *prli, unsigned short prliLength)
  1018. ;
  1019.     IF ¬ GENERATINGCFM THEN
  1020.         Macro
  1021.         _OCEPackRLIParts
  1022.             move.w              #$0325,D0
  1023.             dc.w                $AA5C
  1024.         EndM
  1025.     ELSE
  1026.         IMPORT_CFM_FUNCTION OCEPackRLIParts
  1027.     ENDIF
  1028.  
  1029. ;
  1030. ;Check the equality of two packed prlis.
  1031. ;
  1032. ;
  1033. ; pascal Boolean OCEEqualPackedRLI(const PackedRLI *prli1, const PackedRLI *prli2)
  1034. ;
  1035.     IF ¬ GENERATINGCFM THEN
  1036.         Macro
  1037.         _OCEEqualPackedRLI
  1038.             move.w              #$0313,D0
  1039.             dc.w                $AA5C
  1040.         EndM
  1041.     ELSE
  1042.         IMPORT_CFM_FUNCTION OCEEqualPackedRLI
  1043.     ENDIF
  1044.  
  1045. ;
  1046. ;Check the validity of a packed RLI.  This checks that the catalog name length
  1047. ;is within bounds, and the packed pathname (if specified) is valid.
  1048. ;
  1049. ;
  1050. ; pascal Boolean OCEValidPackedRLI(const PackedRLI *prli)
  1051. ;
  1052.     IF ¬ GENERATINGCFM THEN
  1053.         Macro
  1054.         _OCEValidPackedRLI
  1055.             move.w              #$0336,D0
  1056.             dc.w                $AA5C
  1057.         EndM
  1058.     ELSE
  1059.         IMPORT_CFM_FUNCTION OCEValidPackedRLI
  1060.     ENDIF
  1061.  
  1062. ;
  1063. ;If this packed RLI describes a Personal Catalog, this call will return a pointer
  1064. ;to an alias record that can be used to find the actual file.  Otherwise, it returns nil.
  1065. ;
  1066. ;
  1067. ; pascal AliasPtr OCEExtractAlias(const PackedRLI *prli)
  1068. ;
  1069.     IF ¬ GENERATINGCFM THEN
  1070.         Macro
  1071.         _OCEExtractAlias
  1072.             move.w              #$0318,D0
  1073.             dc.w                $AA5C
  1074.         EndM
  1075.     ELSE
  1076.         IMPORT_CFM_FUNCTION OCEExtractAlias
  1077.     ENDIF
  1078.  
  1079. ;
  1080. ;This call returns a pointer to a packed RLI that represents the "Catalogs" icon, or
  1081. ;the root of all catalogs.  It is used in the CollabPack.
  1082. ;
  1083. ;
  1084. ; pascal const PackedRLI *OCEGetDirectoryRootPackedRLI(void )
  1085. ;
  1086.     IF ¬ GENERATINGCFM THEN
  1087.         Macro
  1088.         _OCEGetDirectoryRootPackedRLI
  1089.             move.w              #$0346,D0
  1090.             dc.w                $AA5C
  1091.         EndM
  1092.     ELSE
  1093.         IMPORT_CFM_FUNCTION OCEGetDirectoryRootPackedRLI
  1094.     ENDIF
  1095.  
  1096. ; *** LocalRecordID ***
  1097. LocalRecordID            RECORD 0
  1098. cid                         ds        CreationID        ; offset: $0 (0)
  1099. recordName                 ds.l    1                ; offset: $8 (8)
  1100. recordType                 ds.l    1                ; offset: $C (12)
  1101. sizeof                     EQU *                    ; size:   $10 (16)
  1102.                         ENDR
  1103. ; typedef struct LocalRecordID *        LocalRecordIDPtr
  1104.  
  1105. ;  Create a LocalRecordID from a name, type, and CreationID 
  1106. ;
  1107. ; pascal void OCENewLocalRecordID(const RString *recordName, const RString *recordType, const CreationID *cid, LocalRecordID *lRID)
  1108. ;
  1109.     IF ¬ GENERATINGCFM THEN
  1110.         Macro
  1111.         _OCENewLocalRecordID
  1112.             move.w              #$031E,D0
  1113.             dc.w                $AA5C
  1114.         EndM
  1115.     ELSE
  1116.         IMPORT_CFM_FUNCTION OCENewLocalRecordID
  1117.     ENDIF
  1118.  
  1119. ;
  1120. ;Copy LocalRecordID lRID1 to LocalRecordID lRID2.  lRID2 must already contain
  1121. ;pointers to RString structures large enough to hold copies of the corresponding
  1122. ;fields from lRID1.  A memFull error will be returned if that is not the case.
  1123. ;So if you allocate a brand new empty destination, you must at least set up
  1124. ;its length field.
  1125. ;
  1126. ;
  1127. ; pascal OSErr OCECopyLocalRecordID(const LocalRecordID *lRID1, LocalRecordID *lRID2)
  1128. ;
  1129.     IF ¬ GENERATINGCFM THEN
  1130.         Macro
  1131.         _OCECopyLocalRecordID
  1132.             move.w              #$0302,D0
  1133.             dc.w                $AA5C
  1134.         EndM
  1135.     ELSE
  1136.         IMPORT_CFM_FUNCTION OCECopyLocalRecordID
  1137.     ENDIF
  1138.  
  1139. ;
  1140. ;Check the equality of two local RIDs.
  1141. ;
  1142. ;
  1143. ; pascal Boolean OCEEqualLocalRecordID(const LocalRecordID *lRID1, const LocalRecordID *lRID2)
  1144. ;
  1145.     IF ¬ GENERATINGCFM THEN
  1146.         Macro
  1147.         _OCEEqualLocalRecordID
  1148.             move.w              #$030F,D0
  1149.             dc.w                $AA5C
  1150.         EndM
  1151.     ELSE
  1152.         IMPORT_CFM_FUNCTION OCEEqualLocalRecordID
  1153.     ENDIF
  1154.  
  1155. ; *** ShortRecordID ***
  1156. ShortRecordID            RECORD 0
  1157. rli                         ds.l    1                ; offset: $0 (0)
  1158. cid                         ds        CreationID        ; offset: $4 (4)
  1159. sizeof                     EQU *                    ; size:   $C (12)
  1160.                         ENDR
  1161. ; typedef struct ShortRecordID *        ShortRecordIDPtr
  1162.  
  1163. ;  Create a ShortRecordID from an RLI struct and a CreationID 
  1164. ;
  1165. ; pascal void OCENewShortRecordID(const PackedRLI *theRLI, const CreationID *cid, ShortRecordIDPtr sRID)
  1166. ;
  1167.     IF ¬ GENERATINGCFM THEN
  1168.         Macro
  1169.         _OCENewShortRecordID
  1170.             move.w              #$0321,D0
  1171.             dc.w                $AA5C
  1172.         EndM
  1173.     ELSE
  1174.         IMPORT_CFM_FUNCTION OCENewShortRecordID
  1175.     ENDIF
  1176.  
  1177. ;
  1178. ;Copy ShortRecordID sRID1 to ShortRecordID sRID2.  sRID2 must already contain
  1179. ;pointers to structures large enough to hold copies of the corresponding
  1180. ;fields from sRID1.  A memFull error will be returned if that is not the case.
  1181. ;So if you allocate a brand new empty destination, you must at least set up
  1182. ;its length fields.
  1183. ;
  1184. ;
  1185. ; pascal OSErr OCECopyShortRecordID(const ShortRecordID *sRID1, ShortRecordID *sRID2)
  1186. ;
  1187.     IF ¬ GENERATINGCFM THEN
  1188.         Macro
  1189.         _OCECopyShortRecordID
  1190.             move.w              #$030A,D0
  1191.             dc.w                $AA5C
  1192.         EndM
  1193.     ELSE
  1194.         IMPORT_CFM_FUNCTION OCECopyShortRecordID
  1195.     ENDIF
  1196.  
  1197. ;
  1198. ;Check the equality of two short RIDs.
  1199. ;
  1200. ;
  1201. ; pascal Boolean OCEEqualShortRecordID(const ShortRecordID *sRID1, const ShortRecordID *sRID2)
  1202. ;
  1203.     IF ¬ GENERATINGCFM THEN
  1204.         Macro
  1205.         _OCEEqualShortRecordID
  1206.             move.w              #$0317,D0
  1207.             dc.w                $AA5C
  1208.         EndM
  1209.     ELSE
  1210.         IMPORT_CFM_FUNCTION OCEEqualShortRecordID
  1211.     ENDIF
  1212.  
  1213. ; *** RecordID ***
  1214. RecordID                RECORD 0
  1215. rli                         ds.l    1                ; offset: $0 (0)        ;  pointer to a packed rli structure 
  1216. local                     ds        LocalRecordID    ; offset: $4 (4)
  1217. sizeof                     EQU *                    ; size:   $14 (20)
  1218.                         ENDR
  1219. ; typedef struct RecordID *                RecordIDPtr
  1220.  
  1221. ;
  1222. ;    Create a RecordID from a packed RLI struct and a LocalRecordID.
  1223. ;This doesn't allocate any new space; the RecordID points to the same
  1224. ;packed RLI struct and the same name and type RStrings. 
  1225. ;
  1226. ;
  1227. ; pascal void OCENewRecordID(const PackedRLI *theRLI, const LocalRecordID *lRID, RecordID *rid)
  1228. ;
  1229.     IF ¬ GENERATINGCFM THEN
  1230.         Macro
  1231.         _OCENewRecordID
  1232.             move.w              #$0320,D0
  1233.             dc.w                $AA5C
  1234.         EndM
  1235.     ELSE
  1236.         IMPORT_CFM_FUNCTION OCENewRecordID
  1237.     ENDIF
  1238.  
  1239. ;
  1240. ;Copy RecordID RID1 to RecordID RID2.  RID2 must already contain
  1241. ;pointers to structures large enough to hold copies of the corresponding
  1242. ;fields from lRID1.  A memFull error will be returned if that is not the case.
  1243. ;So if you allocate a brand new empty destination, you must at least set up
  1244. ;its length fields.
  1245. ;
  1246. ;
  1247. ; pascal OSErr OCECopyRecordID(const RecordID *rid1, const RecordID *rid2)
  1248. ;
  1249.     IF ¬ GENERATINGCFM THEN
  1250.         Macro
  1251.         _OCECopyRecordID
  1252.             move.w              #$0309,D0
  1253.             dc.w                $AA5C
  1254.         EndM
  1255.     ELSE
  1256.         IMPORT_CFM_FUNCTION OCECopyRecordID
  1257.     ENDIF
  1258.  
  1259. ;     Check the equality of two RIDs. 
  1260. ;
  1261. ; pascal Boolean OCEEqualRecordID(const RecordID *rid1, const RecordID *rid2)
  1262. ;
  1263.     IF ¬ GENERATINGCFM THEN
  1264.         Macro
  1265.         _OCEEqualRecordID
  1266.             move.w              #$0314,D0
  1267.             dc.w                $AA5C
  1268.         EndM
  1269.     ELSE
  1270.         IMPORT_CFM_FUNCTION OCEEqualRecordID
  1271.     ENDIF
  1272.  
  1273. ; *** PackedRecordID ***
  1274. ;
  1275. ;struct PackedRecordID is a maximum-sized structure.  Allocate one of
  1276. ;these and it will hold any valid packed RecordID.
  1277. ;
  1278.  
  1279. kPackedRecordIDMaxBytes            EQU        1824
  1280. PackedRecordID            RECORD 0
  1281. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1282. data                     ds.b    1824            ; offset: $2 (2)
  1283. sizeof                     EQU *                    ; size:   $722 (1826)
  1284.                         ENDR
  1285. ;
  1286. ;struct ProtoPackedRecordID is a minimum-sized structure.  Use this
  1287. ;for a variable-length packed RecordID.
  1288. ;
  1289. ProtoPackedRecordID        RECORD 0
  1290. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1291. ;  Followed by data 
  1292. sizeof                     EQU *                    ; size:   $2 (2)
  1293.                         ENDR
  1294. ; typedef struct PackedRecordID *        PackedRecordIDPtr
  1295.  
  1296. ; typedef struct ProtoPackedRecordID *    ProtoPackedRecordIDPtr
  1297.  
  1298. ;
  1299. ;Copy PackedRecordID pRID1 to PackedRecordID pRID2.  pRID2 must already contain
  1300. ;pointers to structures large enough to hold copies of the corresponding
  1301. ;fields from pRID1.  A memFull error will be returned if that is not the case.
  1302. ;pRID2Length is the number of bytes that can be put into pRID2, not counting the
  1303. ;packed RecordID header.
  1304. ;
  1305. ;
  1306. ; pascal OSErr OCECopyPackedRecordID(const PackedRecordID *pRID1, const PackedRecordID *pRID2, unsigned short pRID2Length)
  1307. ;
  1308.     IF ¬ GENERATINGCFM THEN
  1309.         Macro
  1310.         _OCECopyPackedRecordID
  1311.             move.w              #$0306,D0
  1312.             dc.w                $AA5C
  1313.         EndM
  1314.     ELSE
  1315.         IMPORT_CFM_FUNCTION OCECopyPackedRecordID
  1316.     ENDIF
  1317.  
  1318. ;
  1319. ;Create a RecordID from a PackedRecordID.
  1320. ;NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1321. ;OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL
  1322. ;
  1323. ;
  1324. ; pascal void OCEUnpackRecordID(const PackedRecordID *pRID, RecordID *rid)
  1325. ;
  1326.     IF ¬ GENERATINGCFM THEN
  1327.         Macro
  1328.         _OCEUnpackRecordID
  1329.             move.w              #$0332,D0
  1330.             dc.w                $AA5C
  1331.         EndM
  1332.     ELSE
  1333.         IMPORT_CFM_FUNCTION OCEUnpackRecordID
  1334.     ENDIF
  1335.  
  1336. ;
  1337. ;Create a PackedRecordID from a RecordID.  pRID must be large enough to contain
  1338. ;the packed RecordID.  A memFull error will be returned if that is not the case.
  1339. ;packedRecordIDLength is the number of bytes that can be put into pRID, not
  1340. ;counting the header.
  1341. ;
  1342. ;
  1343. ; pascal OSErr OCEPackRecordID(const RecordID *rid, PackedRecordID *pRID, unsigned short packedRecordIDLength)
  1344. ;
  1345.     IF ¬ GENERATINGCFM THEN
  1346.         Macro
  1347.         _OCEPackRecordID
  1348.             move.w              #$0326,D0
  1349.             dc.w                $AA5C
  1350.         EndM
  1351.     ELSE
  1352.         IMPORT_CFM_FUNCTION OCEPackRecordID
  1353.     ENDIF
  1354.  
  1355. ;
  1356. ;Compute the number of bytes of memory needed to hold a RecordID when packed. This
  1357. ;length includes the length of the length field of PackedRecordID, so it
  1358. ;is safe to do a NewPtr (OCEPackedRecordIDSize(...)).
  1359. ;
  1360. ;
  1361. ; pascal unsigned short OCEPackedRecordIDSize(const RecordID *rid)
  1362. ;
  1363.     IF ¬ GENERATINGCFM THEN
  1364.         Macro
  1365.         _OCEPackedRecordIDSize
  1366.             move.w              #$032B,D0
  1367.             dc.w                $AA5C
  1368.         EndM
  1369.     ELSE
  1370.         IMPORT_CFM_FUNCTION OCEPackedRecordIDSize
  1371.     ENDIF
  1372.  
  1373. ;
  1374. ;Check the equality of two packed RIDs.
  1375. ;
  1376. ;
  1377. ; pascal Boolean OCEEqualPackedRecordID(const PackedRecordID *pRID1, const PackedRecordID *pRID2)
  1378. ;
  1379.     IF ¬ GENERATINGCFM THEN
  1380.         Macro
  1381.         _OCEEqualPackedRecordID
  1382.             move.w              #$0312,D0
  1383.             dc.w                $AA5C
  1384.         EndM
  1385.     ELSE
  1386.         IMPORT_CFM_FUNCTION OCEEqualPackedRecordID
  1387.     ENDIF
  1388.  
  1389. ;  OCEValidPackedRecordID checks the validity of a packed record ID. 
  1390. ;
  1391. ; pascal Boolean OCEValidPackedRecordID(const PackedRecordID *pRID)
  1392. ;
  1393.     IF ¬ GENERATINGCFM THEN
  1394.         Macro
  1395.         _OCEValidPackedRecordID
  1396.             move.w              #$0335,D0
  1397.             dc.w                $AA5C
  1398.         EndM
  1399.     ELSE
  1400.         IMPORT_CFM_FUNCTION OCEValidPackedRecordID
  1401.     ENDIF
  1402.  
  1403. ; *** DSSpec ***
  1404. DSSpec                    RECORD 0
  1405. entitySpecifier             ds.l    1                ; offset: $0 (0)
  1406. extensionType             ds.l    1                ; offset: $4 (4)
  1407. extensionSize             ds.w    1                ; offset: $8 (8)
  1408. extensionValue             ds.l    1                ; offset: $A (10)
  1409. sizeof                     EQU *                    ; size:   $E (14)
  1410.                         ENDR
  1411. ; typedef struct DSSpec *                DSSpecPtr
  1412.  
  1413. ;
  1414. ;struct PackedDSSpec is NOT a maximum-sized structure.  Allocate one of
  1415. ;these and it will hold any valid packed RecordID, but not necessarily any additional
  1416. ;data.
  1417. ;
  1418.  
  1419. kPackedDSSpecMaxBytes            EQU        1832
  1420. PackedDSSpec            RECORD 0
  1421. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1422. data                     ds.b    1832            ; offset: $2 (2)
  1423. sizeof                     EQU *                    ; size:   $72A (1834)
  1424.                         ENDR
  1425. ; typedef struct PackedDSSpec *            PackedDSSpecPtr
  1426.  
  1427. ; typedef PackedDSSpecPtr *                PackedDSSpecHandle
  1428.  
  1429. ;
  1430. ;struct ProtoPackedDSSpec is a minimum-sized structure.  Use this
  1431. ;for a variable-length packed DSSpec.
  1432. ;
  1433. ProtoPackedDSSpec        RECORD 0
  1434. dataLength                 ds.w    1                ; offset: $0 (0)        ;  dataLength excludes the space for the dataLength field 
  1435. ;  Followed by data 
  1436. sizeof                     EQU *                    ; size:   $2 (2)
  1437.                         ENDR
  1438. ; typedef struct ProtoPackedDSSpec *    ProtoPackedDSSpecPtr
  1439.  
  1440. ;
  1441. ;Copy PackedDSSpec pdss1 to PackedDSSpec pdss2.  pdss2 must already contain
  1442. ;pointers to structures large enough to hold copies of the corresponding
  1443. ;fields from pdss1.  A memFull error will be returned if that is not the case.
  1444. ;pdss2Length is the number of bytes that can be put into pdss2, not counting the
  1445. ;packed DSSpec header.
  1446. ;
  1447. ;
  1448. ; pascal OSErr OCECopyPackedDSSpec(const PackedDSSpec *pdss1, const PackedDSSpec *pdss2, unsigned short pdss2Length)
  1449. ;
  1450.     IF ¬ GENERATINGCFM THEN
  1451.         Macro
  1452.         _OCECopyPackedDSSpec
  1453.             move.w              #$0303,D0
  1454.             dc.w                $AA5C
  1455.         EndM
  1456.     ELSE
  1457.         IMPORT_CFM_FUNCTION OCECopyPackedDSSpec
  1458.     ENDIF
  1459.  
  1460. ;
  1461. ;Create a DSSpec from a PackedDSSpec.
  1462. ;NOTE THAT THE UNPACKED STRUCT CONTAINS POINTERS INTO THE PACKED STRUCT - DON'T DELETE
  1463. ;OR REUSE THE PACKED STRUCT UNTIL YOU ARE FINISHED WITH THE UNPACKED STRUCT AS WELL.
  1464. ;A pointer to the extension is returned in dss->extensionValue, and the length of that
  1465. ;extension is returned in dss->extensionSize.  If there is no extension, dss->extensionValue will
  1466. ;be set to nil.  This routine will unpack the RecordID (if any) into rid, unpack the rest
  1467. ;into dss, and set dss->entitySpecifier to rid.
  1468. ;
  1469. ;
  1470. ; pascal void OCEUnpackDSSpec(const PackedDSSpec *pdss, DSSpec *dss, RecordID *rid)
  1471. ;
  1472.     IF ¬ GENERATINGCFM THEN
  1473.         Macro
  1474.         _OCEUnpackDSSpec
  1475.             move.w              #$032F,D0
  1476.             dc.w                $AA5C
  1477.         EndM
  1478.     ELSE
  1479.         IMPORT_CFM_FUNCTION OCEUnpackDSSpec
  1480.     ENDIF
  1481.  
  1482. ;
  1483. ;Create a PackedDSSpec from a DSSpec.  pdss must be large enough to
  1484. ;contain the packed RecordID and any extension.  A memFull error will be returned if that
  1485. ;is not the case.  pdssLength is the number of bytes that can be put into pdss,
  1486. ;not counting the header.
  1487. ;
  1488. ;
  1489. ; pascal OSErr OCEPackDSSpec(const DSSpec *dss, PackedDSSpec *pdss, unsigned short pdssLength)
  1490. ;
  1491.     IF ¬ GENERATINGCFM THEN
  1492.         Macro
  1493.         _OCEPackDSSpec
  1494.             move.w              #$0322,D0
  1495.             dc.w                $AA5C
  1496.         EndM
  1497.     ELSE
  1498.         IMPORT_CFM_FUNCTION OCEPackDSSpec
  1499.     ENDIF
  1500.  
  1501. ;
  1502. ;Compute the number of bytes of memory needed to hold a DSSpec when packed. This
  1503. ;length includes the length of the length field of PackedDSSpec, so it
  1504. ;is safe to do a NewPtr (OCEPackedDSSpecSize(...)).
  1505. ;
  1506. ;
  1507. ; pascal unsigned short OCEPackedDSSpecSize(const DSSpec *dss)
  1508. ;
  1509.     IF ¬ GENERATINGCFM THEN
  1510.         Macro
  1511.         _OCEPackedDSSpecSize
  1512.             move.w              #$0327,D0
  1513.             dc.w                $AA5C
  1514.         EndM
  1515.     ELSE
  1516.         IMPORT_CFM_FUNCTION OCEPackedDSSpecSize
  1517.     ENDIF
  1518.  
  1519. ;
  1520. ;    Check the equality of two DSSpecs.  This compares all fields, even the
  1521. ;extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1522. ;diacrit-insensitive manner. 
  1523. ;
  1524. ;
  1525. ; pascal Boolean OCEEqualDSSpec(const DSSpec *pdss1, const DSSpec *pdss2)
  1526. ;
  1527.     IF ¬ GENERATINGCFM THEN
  1528.         Macro
  1529.         _OCEEqualDSSpec
  1530.             move.w              #$030E,D0
  1531.             dc.w                $AA5C
  1532.         EndM
  1533.     ELSE
  1534.         IMPORT_CFM_FUNCTION OCEEqualDSSpec
  1535.     ENDIF
  1536.  
  1537. ;
  1538. ;    Check the equality of two PackedDSSpecs.  This compares all fields, even the
  1539. ;extension (unless extensionSize == 0).  The extensions are compared in a case-insensitive and
  1540. ;diacrit-insensitive manner. 
  1541. ;
  1542. ;
  1543. ; pascal Boolean OCEEqualPackedDSSpec(const PackedDSSpec *pdss1, const PackedDSSpec *pdss2)
  1544. ;
  1545.     IF ¬ GENERATINGCFM THEN
  1546.         Macro
  1547.         _OCEEqualPackedDSSpec
  1548.             move.w              #$0310,D0
  1549.             dc.w                $AA5C
  1550.         EndM
  1551.     ELSE
  1552.         IMPORT_CFM_FUNCTION OCEEqualPackedDSSpec
  1553.     ENDIF
  1554.  
  1555. ;
  1556. ;Check the validity of a PackedDSSpec.  If extensionType is
  1557. ;'entn', pdss must contain a valid entitySpecifier.  For all other extensionTypes, a nil
  1558. ;entitySpecifier is valid, but if non-nil, it will be checked for validity.  No check
  1559. ;is made on the extension.
  1560. ;
  1561. ;
  1562. ; pascal Boolean OCEValidPackedDSSpec(const PackedDSSpec *pdss)
  1563. ;
  1564.     IF ¬ GENERATINGCFM THEN
  1565.         Macro
  1566.         _OCEValidPackedDSSpec
  1567.             move.w              #$0333,D0
  1568.             dc.w                $AA5C
  1569.         EndM
  1570.     ELSE
  1571.         IMPORT_CFM_FUNCTION OCEValidPackedDSSpec
  1572.     ENDIF
  1573.  
  1574. ;
  1575. ;Return info about a DSSpec.  This routine does not check validity.  If the
  1576. ;DSSpec has no extension, we determine whether it represents the root of all
  1577. ;catalogs, a single catalog, a DNode, or a Record.  Else it is invalid.
  1578. ;If the DSSpec has an extension, we simply return the extension type.
  1579. ;
  1580. ;
  1581. ; pascal OSType OCEGetDSSpecInfo(const DSSpec *spec)
  1582. ;
  1583.     IF ¬ GENERATINGCFM THEN
  1584.         Macro
  1585.         _OCEGetDSSpecInfo
  1586.             move.w              #$0319,D0
  1587.             dc.w                $AA5C
  1588.         EndM
  1589.     ELSE
  1590.         IMPORT_CFM_FUNCTION OCEGetDSSpecInfo
  1591.     ENDIF
  1592.  
  1593. ;  OCEGetExtensionType returns the extensionType imbedded in the PackedDSSpec. 
  1594. ;
  1595. ; pascal OSType OCEGetExtensionType(const PackedDSSpec *pdss)
  1596. ;
  1597.     IF ¬ GENERATINGCFM THEN
  1598.         Macro
  1599.         _OCEGetExtensionType
  1600.             move.w              #$031C,D0
  1601.             dc.w                $AA5C
  1602.         EndM
  1603.     ELSE
  1604.         IMPORT_CFM_FUNCTION OCEGetExtensionType
  1605.     ENDIF
  1606.  
  1607. ;
  1608. ;OCEStreamPackedDSSpec streams (flattens) a catalog object a little at a time by
  1609. ;calling the DSSpecStreamer routine that you provide.
  1610. ;
  1611. ; typedef DSSpecStreamerUPP             DSSpecStreamer
  1612.  
  1613. ;
  1614. ; pascal OSErr OCEStreamPackedDSSpec(const DSSpec *dss, DSSpecStreamer stream, long userData, unsigned long *actualCount)
  1615. ;
  1616.     IF ¬ GENERATINGCFM THEN
  1617.         Macro
  1618.         _OCEStreamPackedDSSpec
  1619.             move.w              #$033D,D0
  1620.             dc.w                $AA5C
  1621.         EndM
  1622.     ELSE
  1623.         IMPORT_CFM_FUNCTION OCEStreamPackedDSSpec
  1624.     ENDIF
  1625.  
  1626. ; *** AttributeType ***
  1627. ;
  1628. ;For the record, an AttributeType is an RString with a smaller maximum size.
  1629. ;I don't just typedef it to an RString, because I want the definition of the AttributeType
  1630. ;struct to contain the max length, because I need to include it in the Attribute struct
  1631. ;below.  But it should be possible to typecast any AttributeType to an RString and use
  1632. ;all the RString utilities on it.
  1633. ;
  1634. AttributeType            RECORD 0
  1635. charSet                     ds.w    1                ; offset: $0 (0)
  1636. dataLength                 ds.w    1                ; offset: $2 (2)
  1637. body                     ds.b    32                ; offset: $4 (4)        ;  always fixed at the max size 
  1638. sizeof                     EQU *                    ; size:   $24 (36)
  1639.                         ENDR
  1640. ; typedef struct AttributeType *        AttributeTypePtr
  1641.  
  1642. ;  Miscellaneous defines:  (these cannot be made into enums) 
  1643.  
  1644. kMinPackedRStringLength            EQU        4
  1645.  
  1646. kMinPackedRLISize                EQU        20
  1647. ; *** AttributeValue ***
  1648. ;  same class as is used in AppleEvents 
  1649. ; typedef DescType                         AttributeTag
  1650.  
  1651. AttributeValue            RECORD 0
  1652. tag                         ds.l    1                ; offset: $0 (0)
  1653. dataLength                 ds.l    1                ; offset: $4 (4)
  1654. bytes                     ds.l    1                ; offset: $8 (8)
  1655. sizeof                     EQU *                    ; size:   $C (12)
  1656.                         ENDR
  1657. ; typedef struct AttributeValue *        AttributeValuePtr
  1658.  
  1659. ; *** Attribute ***
  1660. Attribute                RECORD 0
  1661. attributeType             ds        AttributeType    ; offset: $0 (0)
  1662. cid                         ds        AttributeCreationID ; offset: $24 (36)
  1663. value                     ds        AttributeValue ; offset: $2C (44)
  1664. sizeof                     EQU *                    ; size:   $38 (56)
  1665.                         ENDR
  1666. ; typedef struct Attribute *            AttributePtr
  1667.  
  1668. ;
  1669. ; pascal RString *OCEGetIndRecordType(OCERecordTypeIndex stringIndex)
  1670. ;
  1671.     IF ¬ GENERATINGCFM THEN
  1672.         Macro
  1673.         _OCEGetIndRecordType
  1674.             move.w              #$031B,D0
  1675.             dc.w                $AA5C
  1676.         EndM
  1677.     ELSE
  1678.         IMPORT_CFM_FUNCTION OCEGetIndRecordType
  1679.     ENDIF
  1680.  
  1681. ;
  1682. ; pascal AttributeType *OCEGetIndAttributeType(OCEAttributeTypeIndex stringIndex)
  1683. ;
  1684.     IF ¬ GENERATINGCFM THEN
  1685.         Macro
  1686.         _OCEGetIndAttributeType
  1687.             move.w              #$031A,D0
  1688.             dc.w                $AA5C
  1689.         EndM
  1690.     ELSE
  1691.         IMPORT_CFM_FUNCTION OCEGetIndAttributeType
  1692.     ENDIF
  1693.  
  1694.  
  1695. _oceTBDispatch                    EQU        $AA5E
  1696. ;
  1697. ;***************************************************************************************
  1698. ;   PLEASE NOTE! ROUTINES HAVE MOVED TO THIS HEADER!
  1699. ; 
  1700. ;   OCESizePackedRecipient, OCEPackRecipient, OCEUnpackRecipient, OCEStreamRecipient,
  1701. ;   OCEGetRecipientType, and OCESetRecipientType have moved to the OCE header file.
  1702. ;   The OCEMessaging header includes the OCE header, so no changes to your code are
  1703. ;   required.
  1704. ;
  1705. ;***************************************************************************************
  1706. ;
  1707. OCERecipient            RECORD 0
  1708. f                         ds        DSSpec
  1709. sizeof                     EQU *                    ; size:   $E (14)
  1710.                         ENDR
  1711.  
  1712.  
  1713.  
  1714. kOCESizePackedRecipient            EQU        830
  1715. kOCEPackRecipient                EQU        831
  1716. kOCEUnpackRecipient                EQU        832
  1717. kOCEStreamRecipient                EQU        833
  1718. kOCEGetRecipientType            EQU        834
  1719. kOCESetRecipientType            EQU        835
  1720. ;
  1721. ;Compute the space that a OCERecipient would take if it were in packed
  1722. ;form.  [Note: does NOT even pad extensionSize, so you may get an odd #back out]
  1723. ;Safe to pass dereferenced handle(s).
  1724. ;
  1725. ;
  1726. ; pascal unsigned short OCESizePackedRecipient(const OCERecipient *rcpt)
  1727. ;
  1728.     IF ¬ GENERATINGCFM THEN
  1729.         Macro
  1730.         _OCESizePackedRecipient
  1731.             move.w              #$033E,D0
  1732.             dc.w                $AA5C
  1733.         EndM
  1734.     ELSE
  1735.         IMPORT_CFM_FUNCTION OCESizePackedRecipient
  1736.     ENDIF
  1737.  
  1738. ;
  1739. ;Take an OCERecipient (scatter) and (gather) stream into the specified
  1740. ;buffer.  It is assumed that there is sufficient space in the buffer (that is
  1741. ;OCESizePackedRecipient).  Safe to pass dereferenced handle(s).
  1742. ;
  1743. ;
  1744. ; pascal unsigned short OCEPackRecipient(const OCERecipient *rcpt, void *buffer)
  1745. ;
  1746.     IF ¬ GENERATINGCFM THEN
  1747.         Macro
  1748.         _OCEPackRecipient
  1749.             move.w              #$033F,D0
  1750.             dc.w                $AA5C
  1751.         EndM
  1752.     ELSE
  1753.         IMPORT_CFM_FUNCTION OCEPackRecipient
  1754.     ENDIF
  1755.  
  1756. ;
  1757. ;Take a packed OCERecipient and cast a the OCERecipient frame over it. Returns
  1758. ;amBadDestId if it doesn't look like an OCERecipient. Safe to pass dereferenced
  1759. ;handle(s).
  1760. ;
  1761. ;
  1762. ; pascal OSErr OCEUnpackRecipient(const void *buffer, OCERecipient *rcpt, RecordID *entitySpecifier)
  1763. ;
  1764.     IF ¬ GENERATINGCFM THEN
  1765.         Macro
  1766.         _OCEUnpackRecipient
  1767.             move.w              #$0340,D0
  1768.             dc.w                $AA5C
  1769.         EndM
  1770.     ELSE
  1771.         IMPORT_CFM_FUNCTION OCEUnpackRecipient
  1772.     ENDIF
  1773.  
  1774. ;
  1775. ;Take an OCERecipient (scatter) and (gather) stream using the specified
  1776. ;function.  Safe to pass dereferenced handle(s).  If streamer function returns
  1777. ;OCEError OCEStreamRecipient stops execution and passes the error back to the caller
  1778. ;
  1779. ; typedef OCERecipientStreamerUPP         OCERecipientStreamer
  1780.  
  1781. ;
  1782. ; pascal OSErr OCEStreamRecipient(const OCERecipient *rcpt, OCERecipientStreamer stream, long userData, unsigned long *actualCount)
  1783. ;
  1784.     IF ¬ GENERATINGCFM THEN
  1785.         Macro
  1786.         _OCEStreamRecipient
  1787.             move.w              #$0341,D0
  1788.             dc.w                $AA5C
  1789.         EndM
  1790.     ELSE
  1791.         IMPORT_CFM_FUNCTION OCEStreamRecipient
  1792.     ENDIF
  1793.  
  1794. ;  Get the OCERecipient's extensionType. Safe to pass dereferenced handle(s).
  1795. ;
  1796. ; pascal OSType OCEGetRecipientType(const CreationID *cid)
  1797. ;
  1798.     IF ¬ GENERATINGCFM THEN
  1799.         Macro
  1800.         _OCEGetRecipientType
  1801.             move.w              #$0342,D0
  1802.             dc.w                $AA5C
  1803.         EndM
  1804.     ELSE
  1805.         IMPORT_CFM_FUNCTION OCEGetRecipientType
  1806.     ENDIF
  1807.  
  1808. ;
  1809. ;Set the OCERecipient's extensionType in the specified cid.  (Note: we do NOT
  1810. ;check for a nil pointer).  If the extensionType is 'entn', the cid is assumed
  1811. ;to be "valid" and is not touched.  Note: to properly handle non 'entn''s this
  1812. ;routine must and will zero the high long (source) of the cid! Safe to pass
  1813. ;dereferenced handle(s).
  1814. ;
  1815. ;
  1816. ; pascal void OCESetRecipientType(OSType extensionType, CreationID *cid)
  1817. ;
  1818.     IF ¬ GENERATINGCFM THEN
  1819.         Macro
  1820.         _OCESetRecipientType
  1821.             move.w              #$0343,D0
  1822.             dc.w                $AA5C
  1823.         EndM
  1824.     ELSE
  1825.         IMPORT_CFM_FUNCTION OCESetRecipientType
  1826.     ENDIF
  1827.  
  1828. ;
  1829. ;***************************************************************************************
  1830. ;   PLEASE NOTE! ROUTINES HAVE MOVED TO THIS HEADER!
  1831. ; 
  1832. ;   OCEGetAccessControlDSSpec and its corresponding data type and constants have
  1833. ;   moved to the OCE header from OCEAuthDir. The OCEAuthDir header includes the OCE
  1834. ;   header, so no changes to your code are required.
  1835. ;   
  1836. ;***************************************************************************************
  1837. ;
  1838. ;  access categories bit numbers 
  1839.  
  1840. kThisRecordOwnerBit                EQU        0
  1841. kFriendsBit                        EQU        1
  1842. kAuthenticatedInDNodeBit        EQU        2
  1843. kAuthenticatedInDirectoryBit    EQU        3
  1844. kGuestBit                        EQU        4
  1845. kMeBit                            EQU        5
  1846. ;  Values of CategoryMask 
  1847.  
  1848. kThisRecordOwnerMask            EQU        1
  1849. kFriendsMask                    EQU        2
  1850. kAuthenticatedInDNodeMask        EQU        4
  1851. kAuthenticatedInDirectoryMask    EQU        8
  1852. kGuestMask                        EQU        16
  1853. kMeMask                            EQU        32
  1854. ; typedef unsigned long                 CategoryMask
  1855.  
  1856. ;
  1857. ;pass kThisRecordOwnerMask, kFriendsMask, kAuthenticatedInDNodeMask, kAuthenticatedInDirectoryMask,
  1858. ;kGuestMask, or kMeMask to this routine, and it will return a pointer to a
  1859. ;DSSpec that can be used in the Get or Set Access Controls calls.
  1860. ;
  1861. ;
  1862. ; pascal DSSpecPtr OCEGetAccessControlDSSpec(CategoryMask categoryBitMask)
  1863. ;
  1864.     IF ¬ GENERATINGCFM THEN
  1865.         Macro
  1866.         _OCEGetAccessControlDSSpec
  1867.             move.w              #$0345,D0
  1868.             dc.w                $AA5C
  1869.         EndM
  1870.     ELSE
  1871.         IMPORT_CFM_FUNCTION OCEGetAccessControlDSSpec
  1872.     ENDIF
  1873.  
  1874.     ENDIF
  1875.     ENDIF ; __OCE__ 
  1876.  
  1877.